package com.kk.demo.java8.memory02;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class TestOnly {
    // 隐式锁对象object对象
    static Object lock = new Object();

    // 集体对象
    static ArrayList<String> datas = new ArrayList<String>();

    public static void main(String[] args) throws InterruptedException {
        // 偶数转换为 MThread对象
        // 奇数转换为NThread对象

        List<Thread> threads = IntStream.range(1, 10).mapToObj(i -> {
            if (i % 2 == 0) {
                return new MThread("consumer " + i);
            } else
                return new NThread("producer " + i);
        }).filter(t -> {
            t.start();
            return true;
        }).collect(Collectors.toList());

        // 进行运行，并等待线程中止
        threads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {

            }
        });

    }
}

/**
 * 偶数类运行
 * @author liujun
 * @date 2016年9月6日
 * @verion 0.0.1
 */
class MThread extends Thread {

    public MThread(String string) {
        this.setName(string);
    }

    public void run() {
        while (true) {
            // 获得阴式锁对象
            synchronized (TestOnly.lock) {
                // 集合对象为空的时间
                if (TestOnly.datas.isEmpty()) {

                    System.out.println(Thread.currentThread().getName() + " into wait ,because empty ");
                    try {
                        // 锁对象将等待
                        TestOnly.lock.wait();
                    } catch (InterruptedException e) {
                        break;

                    }
                    System.out.println(Thread.currentThread().getName() + " wait finished ");
                }
                // 唤醒之后还为空，将退出系统
                if (TestOnly.datas.isEmpty()) {

                    System.out.println("impossible empty !! " + Thread.currentThread().getName());
                    System.exit(-1);
                }
                // 打印信息
                TestOnly.datas
                        .forEach(s -> System.out.println("当前类名:" + Thread.currentThread().getName() + ":当前值 :" + s));
                // 清空队列
                TestOnly.datas.clear();

            }
        }
    }
}

/**
 * 奇数运行
 * @author liujun
 * @date 2016年9月6日
 * @verion 0.0.1
 */
class NThread extends Thread {
    public NThread(String string) {
        this.setName(string);
    }

    public void run() {
        while (true) {
            // 限式锁对象
            synchronized (TestOnly.lock) {
                // 检查集体对象的长度是否大于1
                if (TestOnly.datas.size() > 1) {
                    System.out.println(Thread.currentThread().getName() + " into wait,because full ");
                    try {
                        // 大于1后，则进行等待
                        TestOnly.lock.wait();
                    } catch (InterruptedException e) {
                        break;

                    }
                    System.out.println(Thread.currentThread().getName() + "wait finished ");
                }
                if (TestOnly.datas.size() > 1) {

                    System.out.println("impossible full !! " + Thread.currentThread().getName());
                    System.exit(-1);
                }
                // 构造对象放入对集体中
                IntStream.range(0, 1).forEach(i -> TestOnly.datas.add(i + " data"));

            }
        }
    }
}
